since we don't have gno fully recognized by github atm, i suggest we also support something like

```go,gnodoctest
package foo

func main() {
	a := 42
}
```

Changing 'go' to 'gno' (or using gno) seems fine as it's intended to specify the file extension for temporary executable files.

However, I'm slightly concerned that including multiple elements on a single line when specifying the tag might break syntax highlighting during document rendering, especially using go language tag.

If this isn't an issue, it might be useful to support specifying execution options like ignore or should_panic.

This this a great idea, I have a few questions:

Do we intent to run both go code and gno code in the doctest?
How does Doctest detect this is a gno code?
What is the reason behind using "```go" instead of "````gno" for gno code block?

That's a really good question. Currrently, when rendering markdown, gno doesn't have universal syntax highlighting applied yet (except the custom syntax rule). So, even in official documents like "Effective gno" are using go instead of gno to specify the language.

Considering the purpose of markdown is more for documentation rather than testing, this was an inevitable purpose. So I made it recognize both languages.

However, it doesn't clearly distinguish whether it's completely go or gno. For now, I assume that it's mostly compatible with go and execute it at gno VM level. In other words, even if the language is atually written in go, everything runs as gno. This part may require deeper context analysis in the future.

To summarize in the order of your questions:

1. Even if the code block is specified as Go, it's actually recognized and executed as gno.
2. There's no feature to clearly distinguish between the two languages, and it relies on the language specified in the fenced code block.
3. Go is also set to be recognized due to syntax highlighting.

The main difference between Gno and Go is that Gno has a few native methods unique to blockchain usage. For example:

std.AssertOriginCall
std.GetHeight

Basically, a program can either be Go code or Gno code. We cannot mix them in one source file.

There are a few options I can think of

• Users need to explicitly mark it as either Go code or Gno code, similar to indicating the source code type with a suffix in the filename: xxx.go vs xxx.gno.
• Only support Gno.
• By default, the MD is treated as Gno code. Use gnostd.XXX to indicate that it is Go code. (Not sure if this has much practical purpose; it is more complicated to implement and is only for the sake of supporting Go code with chain functionality in MD.)

the println does not print correct results compared with file tests.

  package main

  type ints []int

  func main() {
        a := ints{1,2,3}
      println(a)
  }

doctest

// Output:
// (slice[(1 int),(2 int),(3 int)] gno.land/r/g14ch5q26mhx3jk5cxl88t278nper264ces4m8nt/run.ints)

file test result is correct. ints is a type defined in main package.
// Output:
// (slice[(1 int),(2 int),(3 int)] main.ints)

It seems this is happening because the code is executed through the VMKeeper.

func ExecuteCodeBlock(c codeBlock, stdlibDir string) (string, error) {
    // ...
    addr := crypto.AddressFromPreimage([]byte("addr1"))
    acc := acck.NewAccountWithAddress(ctx, addr)
    acck.SetAccount(ctx, acc)

    msg2 := vm.NewMsgRun(addr, std.Coins{}, files)

    res, err := vmk.Run(ctx, msg2)
    // ...
}

I used this method to handle stdlibs imports. But honestly, I don't know how to maintain this functionality while also making it output main.

What about replacing it with the proper type when displaying the output in the Markdown?